import { useNotificationStore } from '../stores/notification'
import { useActivityStore } from '../stores/activity'

/**
 * 消息辅助工具
 * 提供创建通知和记录活动的便捷方法
 */
export const messageHelper = {
    /**
     * 创建通知
     * @param {Object} options - 通知选项
     * @param {string} options.title - 通知标题
     * @param {string} options.content - 通知内容
     * @param {string} options.type - 通知类型 (system|inventory|expiry|updates|login|permission)
     * @param {number} options.locationId - 关联的位置ID
     * @param {number} options.itemId - 关联的物品ID
     * @param {number} options.priority - 优先级 (0-低, 1-中, 2-高)
     * @returns {Promise<boolean>} - 是否创建成功
     */
    async createNotification(options) {
        try {
            const notificationStore = useNotificationStore()

            const notification = {
                title: options.title,
                content: options.content,
                type: options.type || 'system',
                locationId: options.locationId,
                itemId: options.itemId,
                priority: options.priority || 0
            }

            return await notificationStore.addNotification(notification)
        } catch (error) {
            console.error('创建通知失败:', error)
            return false
        }
    },

    /**
     * 创建物品过期提醒通知
     * @param {Object} item - 物品信息
     * @param {number} daysLeft - 剩余天数
     * @returns {Promise<boolean>} - 是否创建成功
     */
    async createExpiryNotification(item, daysLeft) {
        return this.createNotification({
            title: '物品即将过期',
            content: `${item.name}将在${daysLeft}天后过期，请及时处理。`,
            type: 'expiry',
            locationId: item.locationId,
            itemId: item.id,
            priority: daysLeft <= 3 ? 2 : 1 // 3天内过期为高优先级
        })
    },

    /**
     * 创建库存不足提醒通知
     * @param {Object} item - 物品信息
     * @returns {Promise<boolean>} - 是否创建成功
     */
    async createLowStockNotification(item) {
        return this.createNotification({
            title: '库存不足提醒',
            content: `${item.name}的库存不足，当前剩余${item.quantity}${item.unit || '个'}。`,
            type: 'inventory',
            locationId: item.locationId,
            itemId: item.id,
            priority: 1 // 中优先级
        })
    },

    /**
     * 创建库存盘点通知
     * @param {string} locationName - 位置名称
     * @param {number} locationId - 位置ID
     * @param {number} totalItems - 物品总数
     * @returns {Promise<boolean>} - 是否创建成功
     */
    async createInventoryCheckNotification(locationName, locationId, totalItems) {
        return this.createNotification({
            title: '库存盘点通知',
            content: `${locationName}的库存盘点已完成，共有${totalItems}件物品。`,
            type: 'inventory',
            locationId: locationId,
            priority: 0 // 低优先级
        })
    },

    /**
     * 创建用户登录通知
     * @param {Object} user - 用户信息 { id, name }
     * @param {string} deviceInfo - 设备信息
     * @param {string} loginTime - 登录时间
     * @returns {Promise<boolean>} - 是否创建成功
     */
    async createLoginNotification(user, deviceInfo, loginTime) {
        return this.createNotification({
            title: '系统登录通知',
            content: `用户${user.name || user.username}于${loginTime}通过${deviceInfo}登录系统。`,
            type: 'login',
            userId: user.id,
            priority: 0
        })
    },

    /**
     * 创建用户登出通知
     * @param {Object} user - 用户信息 { id, name }
     * @param {string} logoutTime - 登出时间
     * @returns {Promise<boolean>} - 是否创建成功
     */
    async createLogoutNotification(user, logoutTime) {
        return this.createNotification({
            title: '系统登出通知',
            content: `用户${user.name || '未知用户'}于${logoutTime}登出系统。`,
            type: 'login',
            userId: user.id,
            priority: 0
        })
    },

    /**
     * 创建用户权限变更通知
     * @param {Object} user - 被变更权限的用户
     * @param {string} locationName - 位置名称
     * @param {number} locationId - 位置ID
     * @param {string} oldRole - 旧角色
     * @param {string} newRole - 新角色
     * @param {Object} operatorUser - 操作人用户
     * @returns {Promise<boolean>} - 是否创建成功
     */
    async createPermissionChangeNotification(user, locationName, locationId, oldRole, newRole, operatorUser) {
        return this.createNotification({
            title: '权限变更通知',
            content: `用户${user.name || user.username}在${locationName}的权限被${operatorUser.name || operatorUser.username}从"${oldRole}"更改为"${newRole}"。`,
            type: 'permission',
            locationId: locationId,
            priority: 1 // 中优先级
        })
    },

    /**
     * 创建添加用户到位置通知
     * @param {Object} user - 被添加的用户
     * @param {string} locationName - 位置名称
     * @param {number} locationId - 位置ID
     * @param {string} role - 角色
     * @param {Object} operatorUser - 操作人用户
     * @returns {Promise<boolean>} - 是否创建成功
     */
    async createUserAddedToLocationNotification(user, locationName, locationId, role, operatorUser) {
        return this.createNotification({
            title: '用户访问权限通知',
            content: `用户${user.name || user.username}被${operatorUser.name || operatorUser.username}添加到${locationName}，角色为"${role}"。`,
            type: 'permission',
            locationId: locationId,
            priority: 1 // 中优先级
        })
    },

    /**
     * 创建从位置移除用户通知
     * @param {Object} user - 被移除的用户
     * @param {string} locationName - 位置名称
     * @param {number} locationId - 位置ID
     * @param {Object} operatorUser - 操作人用户
     * @returns {Promise<boolean>} - 是否创建成功
     */
    async createUserRemovedFromLocationNotification(user, locationName, locationId, operatorUser) {
        return this.createNotification({
            title: '用户访问权限撤销通知',
            content: `用户${user.name || user.username}被${operatorUser.name || operatorUser.username}从${locationName}中移除。`,
            type: 'permission',
            locationId: locationId,
            priority: 1 // 中优先级
        })
    },

    /**
     * 记录活动
     * @param {Object} options - 活动选项
     * @param {string} options.title - 活动标题
     * @param {string} options.content - 活动内容
     * @param {string} options.actionType - 活动类型 (create|update|delete|move|login|logout|permission)
     * @param {string} options.userName - 用户名称
     * @param {string} options.locationName - 位置名称
     * @param {number} options.locationId - 位置ID
     * @param {string} options.itemName - 物品名称
     * @param {number} options.itemId - 物品ID
     * @returns {Promise<boolean>} - 是否记录成功
     */
    async recordActivity(options) {
        try {
            const activityStore = useActivityStore()

            // 移除对userName的处理，只使用userId
            // 如果未提供userId则从localStorage获取
            if (!options.userId) {
                options.userId = localStorage.getItem('userId');
            }

            const activity = {
                title: options.title,
                content: options.content,
                actionType: options.actionType,
                // 移除userName字段
                // 兼容新旧字段名称
                locationName: options.locationName || options.specificLocation,
                specificLocation: options.specificLocation || options.locationName,
                locationId: options.locationId,
                itemName: options.itemName,
                itemId: options.itemId,
                userId: options.userId
            }

            return await activityStore.recordActivity(activity)
        } catch (error) {
            console.error('记录活动失败:', error)
            return false
        }
    },

    /**
     * 记录物品创建活动
     * @param {Object} item - 物品信息
     * @param {string} locationName - 位置名称
     * @returns {Promise<boolean>} - 是否记录成功
     */
    async recordItemCreated(item, locationName) {
        // 获取当前用户ID
        const userId = localStorage.getItem('userId') || undefined;

        return this.recordActivity({
            title: '添加新物品',
            content: `添加了新物品"${item.name}"到${locationName}`,
            actionType: 'create',
            specificLocation: locationName,
            locationId: item.locationId,
            itemName: item.name,
            itemId: item.id,
            userId: userId
        })
    },

    /**
     * 记录物品更新活动
     * @param {Object} item - 物品信息
     * @param {string} locationName - 位置名称
     * @param {string} changeDetails - 变更详情
     * @returns {Promise<boolean>} - 是否记录成功
     */
    async recordItemUpdated(item, locationName, changeDetails) {
        // 获取当前用户ID
        const userId = localStorage.getItem('userId') || undefined;

        return this.recordActivity({
            title: '更新物品信息',
            content: `更新了"${item.name}"的${changeDetails}`,
            actionType: 'update',
            specificLocation: locationName,
            locationId: item.locationId,
            itemName: item.name,
            itemId: item.id,
            userId: userId
        })
    },

    /**
     * 记录物品删除活动
     * @param {Object} item - 物品信息
     * @param {string} locationName - 位置名称
     * @param {string} reason - 删除原因
     * @returns {Promise<boolean>} - 是否记录成功
     */
    async recordItemDeleted(item, locationName, reason = '') {
        // 获取当前用户ID
        const userId = localStorage.getItem('userId') || undefined;

        let content = `删除了"${item.name}"`;
        if (reason) {
            content += `，原因：${reason}`;
        }

        return this.recordActivity({
            title: '删除物品',
            content: content,
            actionType: 'delete',
            specificLocation: locationName,
            locationId: item.locationId,
            itemName: item.name,
            itemId: item.id,
            userId: userId
        })
    },

    /**
     * 记录物品移动活动
     * @param {Object} item - 物品信息
     * @param {string} fromLocation - 原位置名称
     * @param {string} toLocation - 目标位置名称
     * @returns {Promise<boolean>} - 是否记录成功
     */
    async recordItemMoved(item, fromLocation, toLocation) {
        // 获取当前用户ID
        const userId = localStorage.getItem('userId') || undefined;

        return this.recordActivity({
            title: '移动物品位置',
            content: `将"${item.name}"从${fromLocation.name}移动到${toLocation.name}`,
            actionType: 'move',
            userId: userId,
            specificLocation: toLocation.name,
            locationId: toLocation.id,
            itemName: item.name,
            itemId: item.id
        })
    },

    /**
     * 记录用户登录活动
     * @param {Object} user - 用户信息 { id, name }
     * @param {string} deviceInfo - 设备信息
     * @returns {Promise<boolean>} - 是否记录成功
     */
    async recordUserLogin(user, deviceInfo) {
        return this.recordActivity({
            title: '用户登录',
            content: `用户通过${deviceInfo}登录系统。`,
            actionType: 'login',
            userId: user.id
        })
    },

    /**
     * 记录用户登出活动
     * @param {Object} user - 用户信息 { id, name }
     * @returns {Promise<boolean>} - 是否记录成功
     */
    async recordUserLogout(user) {
        return this.recordActivity({
            title: '用户登出',
            content: '用户登出系统。',
            actionType: 'logout',
            userId: user.id
        })
    },

    /**
     * 记录权限变更活动
     * @param {Object} user - 被变更权限的用户
     * @param {string} locationName - 位置名称
     * @param {number} locationId - 位置ID
     * @param {string} oldRole - 旧角色
     * @param {string} newRole - 新角色
     * @param {Object} operatorUser - 操作人用户
     * @returns {Promise<boolean>} - 是否记录成功
     */
    async recordPermissionChange(user, locationName, locationId, oldRole, newRole, operatorUser) {
        return this.recordActivity({
            title: '权限变更',
            content: `用户${operatorUser.name || operatorUser.username}将${user.name || user.username}在${locationName}的权限从"${oldRole}"更改为"${newRole}"`,
            actionType: 'permission',
            userId: operatorUser.id,
            locationName: locationName,
            locationId: locationId
        })
    }
} 